#command.py
import base64
import json
import logging
import pyttsx3
import pyautogui
import keyboard
import pyperclip
import requests
import roman
import time
import helper
import random
import wikipedia
from spotipy.oauth2 import SpotifyClientCredentials
from logg           import logger
from io             import BytesIO
from PIL            import Image, ImageGrab
from telebot        import TeleBot, types
from telebot.types  import ReactionTypeEmoji
from Config         import *
from Token          import API_URL, API_KEY, SECRET_KEY
from rich.console   import Console
from rich.table     import Table

last_command_time = {}
engine = pyttsx3.init()
voices = engine.getProperty("voices")
console = Console()



# команды
def add_message_handler(bot: TeleBot):


    @bot.message_handler(commands=["start"])
    def handle_start(message):
        bot.send_message(
            message.chat.id,
            "Привет! Это я! FireBot вы можете написать /helper для просмотра доступных команд",
        )


    @bot.message_handler(
        func=lambda message: message.from_user.id == ignored_user_id,
        commands=[
            "start",
            "help",
            "ai",
            "wh",
            "helper",
            "helperdi",
            "conver",
            "v",
            "text",
            "info",
            "id",
            "pin",
            "remove_keyboard",
            "wiki",
            "creators",
            "test",
            "Go",
            "ruby",
            "copy",
            "paste",
            "enter",
        ],
    )
    def ignore_commands_from_user(message):
        # Игнорировать команды от определенного пользователя
        pass
        bot.reply_to(message, "Не доступно")

    WEBHOOK_URL_DISCORD = webhookurldiscord
    @bot.message_handler(commands=["wh"])
    def handle_webhook_command(message):
        # Получаем имя пользователя и его текст сообщения
        username = message.from_user.username
        text = message.text.replace("/wh", "").strip()

        # Проверяем, что сообщение не пустое
        if not text:
            bot.reply_to(message, "Вы не можете отправить пустое сообщение!")
            return

        # Формируем текст сообщения
        text_to_send = f"{text}"

        # Отправляем сообщение в Discord через Webhook
        send_message_to_discord(username, text_to_send)
        bot.reply_to(message, "Успех!")

    def send_message_to_discord(username, text):
        data = {"content": text, "username": f"{username}"}

        response = requests.post(WEBHOOK_URL_DISCORD, json=data)

        if response.status_code != 204:
            print(
                f"Ошибка при отправке сообщения в Discord. Код: {response.status_code}, Текст: {response.text}"
            )

    reactions = ["👍", "👎", "❤", "🔥", "🥰", "👏", "😁", "🤔", "🤯", "😱", "🤬", "😢", "🎉", "🤩", "🤮", "💩", "🙏", "👌", "🕊", "🤡", "🥱", "🥴", "😍", "🐳", "❤‍🔥", "🌚", "🌭", "💯", "🤣", "⚡", "🍌", "🏆", "💔", "🤨", "😐", "🍓", "🍾", "💋", "🖕", "😈", "😴", "😭", "🤓", "👻", "👨‍💻", "👀", "🎃", "🙈", "😇", "😨", "🤝", "✍", "🤗", "🫡", "🎅", "🎄", "☃", "💅", "🤪", "🗿", "🆒", "💘", "🙉", "🦄", "😘", "💊", "🙊", "😎", "👾", "🤷‍♂", "🤷", "🤷‍♀", "😡"]

    # Обработчик текстового сообщения "пинг"
    @bot.message_handler(regexp="^пинг$")
    def ping_message(message):
        # Проверка ID отправителя
        if message.from_user.id == user id:
            # Случайный выбор одной реакции из списка
            random_reaction = random.choice(reactions)
            # Создание объекта ReactionTypeEmoji для выбранной реакции
            reaction_object = types.ReactionTypeEmoji(random_reaction)
            # Добавление реакции к сообщению
            bot.reply_to(message, F"Понг {reaction_object.emoji}")
            bot.set_message_reaction(message.chat.id, message.message_id, [reaction_object])


    def get_imported_libraries(file_paths):
        imported_libraries = set()
        for file_path in file_paths:
            with open(
                file_path, "r", encoding="utf-8"
            ) as file:  # Указываем кодировку UTF-8
                for line in file:
                    if line.strip().startswith("import ") or line.strip().startswith(
                        "from "
                    ):
                        words = line.split()
                        if len(words) > 1:
                            imported_library = words[1].split(".")[0]
                            imported_libraries.add(imported_library)
        return imported_libraries


    @bot.message_handler(regexp="Бухать хочу")
    def command_help(message):
        # Проверяем ID чата
        bot.send_chat_action(message.chat.id, "typing")
        time.sleep(2.5)

        # Проверяем ID пользователя
        if message.from_user.id == 1610811462:
            bot.reply_to(
                message, "Бля создатель я с тобой хоть на край света конечно идем!"
            )
        else:
            bot.send_message(message.chat.id, "нельзя сука")

    @bot.message_handler(commands=["helper"])
    def handle_helper_command(message):
        response = helper.helper_command()
        bot.send_message(message.chat.id, response)

    @bot.message_handler(commands=["helperdi"])
    def handle_helper_command(message):
        response = helper.helper_commanddi()
        bot.send_message(message.chat.id, response)

    # Команда для теста
    @bot.message_handler(commands=["test"])
    def handle_test_command(message):
        bot.send_message(message.chat.id, "Привет! Это ответ на команду /test.")

    # Команда чтобы убрать экранную клавиатуру
    @bot.message_handler(commands=["remove_keyboard"])
    def remove_keyboard(message):
        # Создаем пустую клавиатуру
        markup = types.ReplyKeyboardRemove()
        # Отправляем сообщение с пустой клавиатурой
        bot.send_message(message.chat.id, "Клавиатура убрана.", reply_markup=markup)

    # Обработчик команды /id
    @bot.message_handler(commands=["id"])
    def get_user_id(message):
        # Отправляем ID пользователя, отправившего команду
        user_id = message.from_user.id

        # Замените 'YOUR_USER_ID' на ваш реальный ID в Telegram

        # Получаем имя чата
        if message.chat.type == "private":
            chat_name = message.chat.first_name
        elif message.chat.type in ["group", "supergroup"]:
            chat_name = (
                message.chat.title
                if hasattr(message.chat, "title")
                else "Unknown Group"
            )
        elif message.chat.type == "channel":
            chat_name = (
                message.chat.username
                if hasattr(message.chat, "username")
                else "Unknown Channel"
            )
        else:
            chat_name = "Unknown Chat"

        # Отправляем ID пользователя и имя чата в ваш личный чат
        bot.send_message(
            show_user_id, f"ID пользователя {message.from_user.first_name}: {user_id}"
        )
        bot.send_message(show_user_id, f"ID чата {chat_name}: {message.chat.id}")

        # Отправляем ID чата обратно в этот чат
        bot.send_message(
            message.chat.id, f"ID этого чата {chat_name}: {message.chat.id}"
        )

    # Обработчик команды /wiki
    @bot.message_handler(commands=["wiki"])
    def search_wikipedia(message):
        try:
            if len(message.text.split()) > 1:
                search_query = " ".join(message.text.split()[1:])

                wikipedia.set_lang("ru")
                html_content = wikipedia.page(search_query).html()
                result = wikipedia.summary(search_query, sentences=3)

                bot.reply_to(message, result)
            else:
                bot.reply_to(
                    message, "Пожалуйста, укажите слово для поиска после команды /wiki."
                )
        except Exception as e:
            bot.reply_to(
                message,
                "Извините, я не смог найти информацию в Википедии. Попробуйте другой запрос или проверьте свои данные.",
            )
        
    def send_chat_info(chat_id, chat_title, members_count, new_user):
        # Создаем объект таблицы
        table = Table(title="Новый участник в чате")
        
        # Добавляем столбцы в таблицу
        table.add_column("Чат", style="bold green")
        table.add_column("Участники", style="bold magenta")
        table.add_column("Новый пользователь", style="bold magenta")
        
        # Добавляем строки с данными
        table.add_row(chat_title, str(members_count), new_user)
        
        # Выводим таблицу в консоль
        console.print(table)
    
    # Обработчик события добавления новых участников в чат
    @bot.message_handler(func=lambda message: True, content_types=["new_chat_members"])
    def handle_new_chat_members(message):
        chat_id = message.chat.id
        new_members = message.new_chat_members
        
        # Получаем информацию о чате
        chat_title = message.chat.title
        members_count = bot.get_chat_members_count(chat_id)
        
        for member in new_members:
            new_user = member.first_name if member else "неизвестно"
            
            # Отправляем информацию о чате в терминал
            send_chat_info(chat_id, chat_title, members_count, new_user)
        
        # Отправляем приветственное сообщение, если бот добавлен в чат
        for member in new_members:
            if member.id == bot.get_me().id:
                chat_name = message.chat.title if message.chat.title else "этого чата"
                creator_name = message.from_user.first_name if message.from_user else "мой создатель"
                
                bot.send_chat_action(chat_id, "typing")
                time.sleep(4.5)
                
                welcome_message = f"Мой покровитель {creator_name} добавил меня в чат '{chat_name}'. Я всегда готов к вашим админским владениям, {creator_name}!"
                bot.send_message(chat_id, welcome_message)
                break

    @bot.message_handler(commands=["leave"])
    def leave_command(message):
        # Проверяем, является ли сообщение из чата
        if message.chat.type == "private":
            bot.reply_to(
                message, "Это так не работает, попробуй эту команду в групповом чате!"
            )
        else:
            # Выбираем случайное прощальное сообщение
            farewell_messages = [
                "да ну вас к черту! Я ухожу!",
                "Понял, я покину вас.",
                "Прощайте!",
                "Ой, кажется вы злы на меня. Я выйду!",
                "да ну вас к черту! Я ухожу!",
                "Понял, я покину вас.",
                "Прощайте!",
                "Ой, кажется вы злы на меня. Я выйду!",
                "Я ухожу, но обещаю вернуться!",
                "Вам больше не нужна моя помощь? Хорошо, я ухожу.",
                "Пора мне идти. Увидимся позже!",
                "Это было приятно, но мне пора в другие миры.",
                "Не расстраивайтесь, я вернусь, когда меня позовут!",
                "Прощайте, мои дорогие друзья! Помните обо мне.",
                "Мне кажется, я здесь больше не нужен. Удачи вам!",
                "Вот и пришло время мне уйти. До свидания!",
                "Очень жаль, что мне приходится уходить. Но иногда нужно делать непопулярные решения.",
                "Спасибо за всё! До новых встреч!",
                "Прощайте, и помните, что я всегда готов помочь!",
                "Моя работа здесь закончена. До свидания!",
                "Увидимся в другой раз!",
                "Не грустите, я скоро вернусь!",
                "Пока-пока! Будьте здоровы!",
                "Не забывайте обо мне! Я всегда здесь, если вам нужна помощь.",
                "До встречи, мои друзья! Берегите себя!",
                "Увидимся в следующий раз!",
                "Пора мне уйти. Возможно, у нас ещё встреча впереди.",
                "До свидания! Желаю вам всего наилучшего!",
                "Спасибо за время, проведённое вместе. Я ухожу.",
                "Мне пришло время уйти. Помните обо мне.",
                "Увидимся! Надеюсь, что не в последний раз.",
                "Вот и пришло время прощаться. До новых встреч!",
                "Прощайте, друзья! Надеюсь, мы ещё увидимся!",
                "Спасибо за всё. Я ухожу.",
                "Не печальтесь, я всегда рядом, даже если не видно!",
                "Мне нужно уйти, но я всегда здесь, если что-то понадобится.",
                "Увидимся позже! Будьте здоровы!",
                "Время для меня уйти. До свидания!",
                "Спасибо за все моменты вместе. Я ухожу.",
                "Не грустите, я всегда вернусь, когда меня позовут!",
                "Пока, друзья! Надеюсь, увидимся снова.",
                "Уходить никогда не приятно, но это нужно сделать. До свидания!",
                "Будьте счастливы! До встречи!",
                "Пора мне уйти. Удачи вам!",
                "Вот и прощание. До свидания!",
                "Спасибо за всё. Я ухожу.",
                "Пока, мои друзья! Желаю вам всего наилучшего!",
                "Увидимся! Надеюсь, не слишком скоро!",
                "Время для меня уйти. Будьте здоровы!",
                "Прощайте! Надеюсь, мы встретимся снова.",
                "Не забывайте обо мне! Я всегда рядом.",
                "Пора мне уходить. Увидимся!",
                "Спасибо за всё время вместе. Я ухожу.",
                "До свидания, друзья! Берегите себя!",
                "Увидимся позже! Всего доброго!",
                "Не забывайте обо мне. Я всегда здесь, если что-то понадобится.",
                "Пора мне уходить. Спасибо за всё!",
                "Прощайте! Надеюсь, мы встретимся снова!",
                "Не грустите, это не прощание навсегда. До свидания!",
                "Время для меня уйти. Буду скучать!",
                "Пока-пока! Жду новых встреч!",
                "Спасибо за всё! Удачи вам!",
                "До новых встреч, мои друзья!",
                "Увидимся в следующий раз! Будьте счастливы!",
                "Не грустите! Я всегда здесь, когда меня позовут.",
                "Пока-пока! Будьте здоровы!",
                "До свидания! Надеюсь, это не прощание навсегда.",
                "Спасибо за все моменты вместе. Желаю вам всего наилучшего!",
                "До скорого! Жду новых встреч!",
                "Увидимся позже! Помните обо мне.",
            ]
            farewell_message = random.choice(farewell_messages)

            # Отправляем прощальное сообщение в чат
            bot.send_message(message.chat.id, farewell_message)

            # Покидаем чат
            bot.leave_chat(message.chat.id)

    # Класс с ии от сбера
    class Text2ImageAPI:
        def __init__(self, url, api_key, secret_key):
            self.URL = url
            self.AUTH_HEADERS = {
                "X-Key": f"Key {api_key}",
                "X-Secret": f"Secret {secret_key}",
            }

        def get_model(self):
            response = requests.get(
                self.URL + "key/api/v1/models", headers=self.AUTH_HEADERS
            )
            data = response.json()
            return data[0]["id"]

        def generate(self, prompt, model, images=1, width=1024, height=1024):
            params = {
                "type": "GENERATE",
                "numImages": images,
                "width": width,
                "height": height,
                "generateParams": {"query": f"{prompt}"},
            }

            data = {
                "model_id": (None, model),
                "params": (None, json.dumps(params), "application/json"),
            }
            response = requests.post(
                self.URL + "key/api/v1/text2image/run",
                headers=self.AUTH_HEADERS,
                files=data,
            )
            data = response.json()
            return data["uuid"]

        def check_generation(self, request_id, attempts=10, delay=10):
            while attempts > 0:
                response = requests.get(
                    self.URL + "key/api/v1/text2image/status/" + request_id,
                    headers=self.AUTH_HEADERS,
                )
                data = response.json()
                if data["status"] == "DONE":
                    return data["images"]

                attempts -= 1
                time.sleep(delay)

    # Команда /ai
    # Создаем экземпляр Text2ImageAPI
    api = Text2ImageAPI(API_URL, API_KEY, SECRET_KEY)
    # Обработчик команды "/ai"
    @bot.message_handler(commands=["ai"])
    def handle_messages(message):
        # Обработка только текстовых сообщений
        if message.content_type == "text":
            # Получение ввода пользователя
            prompt = message.text[4:]  # Удаление префикса команды "/ai"

            # Проверка, не превышает ли введенный текст 1000 символов
            if len(prompt) > 1000:
                bot.send_message(
                    message.chat.id,
                    "Пожалуйста, введите текст, который содержит не более 1000 символов после команды /ai.",
                )
                return

            # Проверка на пустой ввод
            if not prompt.strip():
                bot.send_message(
                    message.chat.id,
                    """
Пожалуйста, введите текст после команды /ai. 
Пример команды: /ai Птицы 
Разве это так сложно?
                """,
                )
                return

            try:
                # Уведомление пользователя о принятии запроса
                bot.send_message(
                    message.chat.id, f"Ваш запрос {prompt} был принят, ожидайте."
                )

                # Получение идентификатора модели (предполагается, что реализован метод api.get_model())
                model_id = api.get_model()

                # Генерация изображения и получение UUID
                uuid = api.generate(prompt, model_id)

                # Отправка 'typing' действия до тех пор, пока изображение не будет готово
                while True:
                    images = api.check_generation(uuid)
                    if images[0] is not None:
                        break

                # Сохранение изображения
                image_base64 = images[0]
                image_data = base64.b64decode(image_base64)

                with open("image.jpg", "wb") as file:
                    file.write(image_data)

                # Отправка сгенерированного изображения пользователю с исходным текстом
                bot.reply_to(message, "Держи")
                bot.send_chat_action(message.chat.id, "upload_photo")
                with open("image.jpg", "rb") as photo:
                    bot.send_photo(
                        message.chat.id,
                        photo,
                        caption=f"Генерация по запросу: {prompt}",
                    )
                    bot.send_chat_action(message.chat.id, "cancel")

            except Exception as e:
                # Обработка ошибки и отправка уведомления
                error_message = f"Произошла ошибка: {str(e)} "
                bot.send_message(message.chat.id, error_message)

    # Команда чтобы закрепить пост/текст
    @bot.message_handler(commands=["pin"])  #
    def pin_message(message):
        bot_chat_member = bot.get_chat_member(
            message.chat.id, bot.get_me().id
        )  # Получение информации о чат-модераторе
        if message.chat.type in [
            "group",
            "supergroup",
            "channel",
        ]:  # Проверка на тип чата (возможно, что это группа) и на то, что это группа
            if bot.get_chat_member(message.chat.id, message.from_user.id).status in [
                "administrator",
                "creator",
            ]:
                if bot_chat_member.status in ["administrator", "creator"]:
                    if message.reply_to_message:
                        if message.reply_to_message.content_type == "text":
                            if bot.get_chat(
                                message.chat.id
                            ).permissions.can_pin_messages:
                                bot.pin_chat_message(
                                    message.chat.id, message.reply_to_message.message_id
                                )
                                bot.reply_to(message, "Сообщение успешно закреплено! 🎆")
                            else:
                                bot.reply_to(
                                    message,
                                    "У меня нет прав на закрепление сообщений. :(",
                                )
                        else:
                            bot.reply_to(
                                message, "Нельзя закрепить сервисное сообщение."
                            )
                    else:
                        bot.reply_to(
                            message,
                            "Используйте эту команду ответом на сообщение, которое вы хотите закрепить.",
                        )
                else:
                    bot.reply_to(
                        message,
                        "У меня недостаточно прав для использования этой команды. :(",
                    )
            else:
                bot.reply_to(
                    message, "У вас недостаточно прав для использования этой команды."
                )
        else:
            bot.reply_to(
                message,
                "Эта команда доступна только в группах, супергруппах и каналах.",
            )

    # Команда Голос, узнай что говорят в сообщении без telegram premium!

    @bot.message_handler(commands=["info"])
    def send_info(message):
        if message.chat.type == "private":
            bot.send_message(
                message.chat.id,
                "Эта команда доступна исключительно в чатах, но никак не в личных сообщениях.",
            )
            return

        chat_id = message.chat.id

        # Получение количества участников
        members_count = bot.get_chat_members_count(chat_id)

        # Получение списка администраторов
        admins = bot.get_chat_administrators(chat_id)

        # Получение информации о текущем пользователе (отправившем команду)
        user_info = bot.get_chat_member(chat_id, message.from_user.id)

        # Формирование сообщения с информацией
        response_message = f"Количество участников чата: {members_count}\n\n"
        response_message += "Список администраторов:\n"
        for admin in admins:
            response_message += f"Имя админа: {admin.user.username}\n"
        response_message += f"\nИнформация о вас ({user_info.user.username}):\n"
        response_message += f"Статус: {user_info.status}"

        # Отправка сообщения с информацией в чат
        bot.send_message(chat_id, response_message)

    @bot.message_handler(commands=["text"])
    def send_text(message):
        # Проверяем, что отправитель команды - вы
        if str(message.from_user.id) != authorized_user_id:
            bot.reply_to(message, "Вы не имеете доступа к этой команде.")
            return

        # Разбиваем команду на части
        command_parts = message.text.split(" ", 2)

        if len(command_parts) == 3:
            recipients = set(
                command_parts[1].split("+")
            )  # Используем множество для уникальных получателей
            text = command_parts[2]

            for recipient in recipients:
                try:
                    # Избегаем дублирования кода, используем переменную для чата
                    target_chat_id = chat_ids.get(recipient)

                    if target_chat_id:
                        bot.send_message(
                            message.chat.id,
                            f"Сообщение скоро будет отправлено {recipient}",
                        )
                        # Имитация печати
                        bot.send_chat_action(target_chat_id, "typing")
                        time.sleep(4.5)

                        # Отправляем основное сообщение
                        bot.send_message(target_chat_id, text)

                        # Отправляем сообщение об успешной отправке
                        bot.send_message(
                            message.chat.id,
                            f"Сообщение успешно отправлено в чат {recipient}",
                        )
                    else:
                        bot.send_message(
                            message.chat.id, f"Ошибка: Не найден чат {recipient}"
                        )
                except Exception as e:
                    bot.send_message(
                        message.chat.id,
                        f"Сообщение не удалось отправить пользователю {recipient}, ошибка: {e}",
                    )
        else:
            bot.reply_to(message, "Некорректный формат команды /text")

    def check_developer(func):
        def wrapper(message):
            # Проверка, является ли отправитель разработчиком
            if message.from_user.id in developer_ids:
                return func(message)
            else:
                bot.reply_to(message, "У вас нет прав на выполнение этой команды.")

        return wrapper

    @bot.message_handler(commands=["copy"])
    @check_developer
    def copy_text(message):
        try:
            # Получаем текст после команды /copy
            text_to_copy = message.text.replace("/copy", "", 1).strip()

            # Копируем текст в буфер обмена
            pyperclip.copy(text_to_copy)

            # Отправляем сообщение о том, что текст скопирован
            bot.reply_to(message, f'Текст "{text_to_copy}" скопирован в буфер обмена.')

            # Логируем действие пользователя
            logging.info(
                f"User {message.from_user.username} copied text: {text_to_copy}"
            )

        except Exception as e:
            logging.error(f"Error in copy_text: {e}")

    @bot.message_handler(commands=["paste"])
    @check_developer
    def paste_text(message):
        try:
            # Получаем текст из буфера обмена
            text_to_paste = pyperclip.paste()

            # Имитируем нажатие Ctrl+V
            keyboard.press_and_release("ctrl+v")

            # Отправляем текст в чат
            bot.reply_to(message, f"Вставлен текст: {text_to_paste}")

            # Логируем действие пользователя
            logging.info(
                f"User {message.from_user.username} pasted text: {text_to_paste}"
            )

        except Exception as e:
            logging.error(f"Error in paste_text: {e}")

    @bot.message_handler(commands=["enter"])
    @check_developer
    def press_enter(message):
        try:
            # Имитируем нажатие клавиши Enter
            keyboard.press_and_release("Enter")

            # Отправляем текст в чат
            bot.reply_to(message, "Кнопка Enter нажата!")

            # Логируем действие пользователя
            logging.info(f"User {message.from_user.username} pressed Enter")

        except Exception as e:
            logging.error(f"Error in press_enter: {e}")

    @bot.message_handler(commands=["screen"])
    @check_developer
    def send_screenshot(message):
        try:
            # Получаем координаты текущего окна
            left, top, width, height = (
                pyautogui.getActiveWindow().left,
                pyautogui.getActiveWindow().top,
                pyautogui.getActiveWindow().width,
                pyautogui.getActiveWindow().height,
            )

            # Делаем скриншот текущего окна
            screenshot = ImageGrab.grab(bbox=(left, top, left + width, top + height))

            # Преобразуем изображение в байты
            image_bytes = BytesIO()
            screenshot.save(image_bytes, format="PNG")
            image_bytes.seek(0)

            # Отправляем скриншот в чат
            bot.send_chat_action(message.chat.id, "upload_photo")
            bot.send_photo(message.chat.id, photo=image_bytes)
            bot.send_chat_action(message.chat.id, "cancel")

            # Логируем действие пользователя
            logging.info(f"User {message.from_user.username} sent a screenshot")

        except Exception as e:
            logging.error(f"Error in send_screenshot: {e}")

    @bot.message_handler(commands=["conver"])
    def convert_to_roman(message):
        try:
            # Получаем текст сообщения после команды
            command, number_str = message.text.split()

            # Преобразуем строку с числом в целое число
            number = int(number_str)

            # Проверяем, что число находится в допустимом диапазоне
            if 0 < number < 5000:
                # Преобразуем цифру в римскую запись
                roman_numeral = roman.toRoman(number)

                # Отправляем результат пользователю
                bot.reply_to(message, f"{number} >> {roman_numeral}")
            else:
                bot.reply_to(message, "Пожалуйста, введите число от 1 до 4999.")

        except ValueError:
            # Если пользователь ввел не число, сообщаем об ошибке
            bot.reply_to(message, "Пожалуйста, введите целое число.")
        except Exception as e:
            # Обрабатываем возможные ошибки
            bot.reply_to(message, f"Произошла ошибка: {e}")

    @bot.message_handler(commands=["v"])
    def convert_text_to_speech(message):
        global last_command_time

        try:
            # Извлечение текста из команды
            text = " ".join(message.text.split()[1:])

            # Проверка наличия текста
            if not text:
                bot.reply_to(
                    message,
                    "Введите текст после команды /v для преобразования в голосовое сообщение.",
                )
                return

            # Ограничение по символам
            if len(text) > 280:
                bot.reply_to(
                    message,
                    "Текст слишком длинный. Пожалуйста, введите текст до 280 символов.",
                )
                return

            # Задержка между выполнением команд для разных пользователей
            user_id = message.from_user.id
            current_time = time.time()
            if (
                user_id in last_command_time
                and current_time - last_command_time[user_id] < 2
            ):
                bot.reply_to(
                    message, "Подождите немного перед отправкой следующей команды."
                )
                return
            last_command_time[user_id] = current_time

            # Задержка для имитации отправки
            time.sleep(2)
            bot.send_chat_action(message.chat.id, "typing")

            # Синтез речи
            engine.save_to_file(text, "output.mp3")
            engine.runAndWait()

            # Отправка голосового сообщения в Telegram
            with open("output.mp3", "rb") as audio_file:
                bot.send_voice(message.chat.id, audio_file)

        except Exception as e:
            bot.reply_to(message, f"Произошла ошибка: {str(e)}")

    def get_bedrock_server_info(
        server_address,
    ):  # Получение информации о сервере Bedrock
        url = f"https://api.mcstatus.io/v2/status/bedrock/{server_address}"  # Ссылка на сервер Bedrock для получения информации о серверах

        try:
            response = requests.get(url)
            response.raise_for_status()
            server_data = response.json()

            if "error" in server_data:
                return "Кажется, я не нашел данных об этом сервере. Возможно, он существует, но я не знаю о нем?"

            if server_data["online"]:
                motd = server_data.get("motd", {}).get(
                    "clean", "Не удалось получить MOTD"
                )
                version = server_data.get("version", {}).get(
                    "name", "Не удалось получить версию"
                )
                player_count = server_data.get("players", {}).get(
                    "online", "Не удалось получить количество игроков"
                )
                max_players = server_data.get("players", {}).get(
                    "max", "Не удалось получить максимальное количество игроков"
                )
                host = server_data.get("host", "Не удалось получить хост сервера")
                ip_address = server_data.get(
                    "ip_address", "Не удалось получить IP-адрес сервера"
                )
                eula_blocked = server_data.get("eula_blocked", False)
                retrieved_at = server_data.get(
                    "retrieved_at", "Не удалось получить время получения статуса"
                )
                expires_at = server_data.get(
                    "expires_at", "Не удалось получить время истечения кеша"
                )
                # Другие необходимые данные...

                server_info = (
                    f"============================\n"
                    f"MOTD сервера: {motd}\n"
                    f"Версия сервера: {version}\n"
                    f"Количество игроков онлайн: {player_count}/{max_players}\n"
                    f"Хост сервера: {host}\n"
                    f"IP-адрес сервера: {ip_address}\n"
                    f"Статус EULA: {'Заблокирован' if eula_blocked else 'Не заблокирован'}\n"
                    f"==========Bedrock============"
                )
                return server_info

            else:
                return "Сервер недоступен, возможно он для Java?"

        except requests.exceptions.RequestException as e:
            return f"Бедрок Minecraft: Ой, случилась ошибка! Возможно, вы ввели неправильный IP-адрес сервера?"

    # Игнорируем исключение HTTPError

    def get_server_info(server_address):
        url = f"https://api.mcstatus.io/v2/status/java/{server_address}"

        try:
            response = requests.get(url)
            response.raise_for_status()
            server_data = response.json()

            if "error" in server_data:
                return "Кажется, я не нашел данных об этом сервере. Возможно, он существует, но я не знаю о нем?"

            if server_data["online"]:
                # Извлекаем MOTD, версию и количество игроков из данных о сервере
                motd = server_data.get("motd", {}).get(
                    "clean", "Не удалось получить MOTD"
                )
                version = server_data.get("version", {}).get(
                    "name_raw", "Не удалось получить версию"
                )
                player_count = server_data.get("players", {}).get(
                    "online", "Не удалось получить количество игроков"
                )
                max_players = server_data.get("players", {}).get(
                    "max", "Не удалось получить максимальное количество игроков"
                )
                list_players = server_data.get("players", {}).get("list", [])
                host = server_data.get("host", "Не удалось получить хост сервера")
                ip_address = server_data.get(
                    "ip_address", "Не удалось получить IP-адрес сервера"
                )
                eula_blocked = server_data.get("eula_blocked", False)
                retrieved_at = server_data.get(
                    "retrieved_at", "Не удалось получить время получения статуса"
                )
                expires_at = server_data.get(
                    "expires_at", "Не удалось получить время истечения кеша"
                )
                mods = server_data.get("mods", [])
                plugins = server_data.get("plugins", [])
                srv_record = server_data.get("srv_record", None)

                # Формируем сообщение с информацией о сервере
                server_info = (
                    f"==========Java============\n"
                    f"MOTD сервера: {motd}\n"
                    f"Версия сервера: {version}\n"
                    f"Количество игроков онлайн: {player_count}/{max_players}\n"
                    f"Список игроков:\n"
                )
                for i, player in enumerate(list_players[:10], 1):
                    server_info += (
                        f"- {player.get('name_clean', 'Неизвестный игрок')}\n"
                    )

                if len(list_players) > 10:
                    server_info += f"... (и ещё {len(list_players) - 10} игроков)\n"

                server_info += (
                    f"Хост сервера: {host}\n"
                    f"IP-адрес сервера: {ip_address}\n"
                    f"Статус EULA: {'Заблокирован' if eula_blocked else 'Не заблокирован'}\n"
                )

                if mods:
                    server_info += "Моды сервера:\n"
                    for i, mod in enumerate(mods[:10], 1):
                        server_info += f"- {mod.get('name', 'Название мода неизвестно')} ({mod.get('version', 'Версия неизвестна')})\n"

                    if len(mods) > 10:
                        server_info += f"... (и ещё {len(mods) - 10} модов)\n"
                else:
                    server_info += "Моды сервера: Нет данных\n"

                if plugins:
                    server_info += "Плагины сервера:\n"
                    for i, plugin in enumerate(plugins[:10], 1):
                        server_info += f"- {plugin.get('name', 'Название плагина неизвестно')} ({plugin.get('version', 'Версия неизвестна')})\n"

                    if len(plugins) > 10:
                        server_info += f"... (и ещё {len(plugins) - 10} плагинов)\n"
                else:
                    server_info += "Плагины сервера: Нет данных\n"

                server_info += "==========Bedrock============"

                return server_info

            else:
                return "Сервер недоступен, возможно он для bedrock?"

        except requests.exceptions.RequestException as e:
            return f"Джава Minecraft: Ой, случилась ошибка! Возможно, вы ввели неправильный IP-адрес сервера?"

    # Обработчик команды /start
    @bot.message_handler(commands=["ip"])
    def start_message(message):
        text = message.text.replace("/ip", "").strip()

        # Проверяем, что сообщение не пустое
        if not text:
            bot.reply_to(
                message,
                """
            ведите после /ip айпи сервера, пример команды: 
            /ip example.org или /ip 0.0.0.0:25565
            """,
            )
            return
        server_address = text
        server_info = get_server_info(server_address)
        bot.send_message(message.chat.id, server_info)
        server_info = get_bedrock_server_info(server_address)
        bot.send_message(message.chat.id, server_info)


